/**
 * 密码管理器加密模块
 * 负责所有加密相关的功能，包括密码加密、解密和主密码验证
 */
const CryptoModule = {
    /**
     * 使用高级加密方法加密数据
     * @param {Object} data - 要加密的数据
     * @param {string} masterPassword - 主密码
     * @returns {string} - 加密后的字符串
     */
    encryptData(data, masterPassword) {
        // 使用PBKDF2从主密码派生密钥
        // 随机生成盐值
        const salt = CryptoJS.lib.WordArray.random(128/8);
        
        // 使用PBKDF2派生密钥（使用10000次迭代增强安全性）
        const key = CryptoJS.PBKDF2(masterPassword, salt, {
            keySize: 256/32,
            iterations: 10000
        });
        
        // 随机生成初始化向量
        const iv = CryptoJS.lib.WordArray.random(128/8);
        
        // 加密数据
        const encrypted = CryptoJS.AES.encrypt(JSON.stringify(data), key, { 
            iv: iv,
            padding: CryptoJS.pad.Pkcs7,
            mode: CryptoJS.mode.CBC
        });
        
        // 将盐值、IV和加密数据合并成一个字符串
        // 格式: salt + iv + encryptedData
        const result = salt.toString() + iv.toString() + encrypted.toString();
        return result;
    },

    /**
     * 解密AES加密的数据
     * @param {string} encryptedData - 加密的数据字符串
     * @param {string} masterPassword - 主密码
     * @returns {Object|null} - 解密后的数据或null（如果解密失败）
     */
    decryptData(encryptedData, masterPassword) {
        try {
            // 从加密字符串中提取盐值和IV
            const salt = CryptoJS.enc.Hex.parse(encryptedData.substr(0, 32));
            const iv = CryptoJS.enc.Hex.parse(encryptedData.substr(32, 32));
            const encrypted = encryptedData.substring(64);
            
            // 重新生成密钥
            const key = CryptoJS.PBKDF2(masterPassword, salt, {
                keySize: 256/32,
                iterations: 10000
            });
            
            // 解密
            const decrypted = CryptoJS.AES.decrypt(encrypted, key, { 
                iv: iv,
                padding: CryptoJS.pad.Pkcs7,
                mode: CryptoJS.mode.CBC
            });
            
            // 将解密结果转换回对象
            return JSON.parse(decrypted.toString(CryptoJS.enc.Utf8));
        } catch (e) {
            console.error("解密失败，可能是密码错误:", e);
            return null;
        }
    },

    /**
     * 生成主密码的哈希值（用于验证）
     * @param {string} masterPassword - 主密码
     * @returns {string} - 哈希值
     */
    hashMasterPassword(masterPassword) {
        // 使用SHA-256哈希算法
        return CryptoJS.SHA256(masterPassword).toString();
    },
    
    /**
     * 验证主密码
     * @param {string} inputPassword - 用户输入的密码
     * @param {string} storedHash - 存储的密码哈希
     * @returns {boolean} - 验证是否成功
     */
    verifyMasterPassword(inputPassword, storedHash) {
        const inputHash = this.hashMasterPassword(inputPassword);
        return inputHash === storedHash;
    },

    /**
     * 检查主密码强度
     * @param {string} password - 要检查的密码
     * @returns {string} - 强度评级："weak", "medium", "strong", "very-strong"
     */
    checkPasswordStrength(password) {
        let score = 0;
        
        // 基本长度检查
        if (password.length >= 8) score += 1;
        if (password.length >= 12) score += 1;
        if (password.length >= 16) score += 1;
        
        // 字符多样性检查
        if (/[A-Z]/.test(password)) score += 1;
        if (/[a-z]/.test(password)) score += 1;
        if (/[0-9]/.test(password)) score += 1;
        if (/[^A-Za-z0-9]/.test(password)) score += 1;
        
        // 返回强度级别
        if (score < 4) return "weak";
        if (score < 6) return "medium";
        if (score < 8) return "strong";
        return "very-strong";
    },
    
    /**
     * 生成随机密码
     * @param {number} length - 密码长度
     * @param {Object} options - 选项（包含大写、小写、数字、符号）
     * @returns {string} - 生成的随机密码
     */
    generatePassword(length = 12, options = {
        uppercase: true,
        lowercase: true,
        numbers: true,
        symbols: true
    }) {
        const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
        const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz';
        const numberChars = '0123456789';
        const symbolChars = '!@#$%^&*()_+~`|}{[]:;?><,./-=';
        
        let chars = '';
        if (options.uppercase) chars += uppercaseChars;
        if (options.lowercase) chars += lowercaseChars;
        if (options.numbers) chars += numberChars;
        if (options.symbols) chars += symbolChars;
        
        if (chars === '') chars = lowercaseChars + numberChars;
        
        // 确保至少有一个字符从每个启用的类别中选择
        let password = '';
        let charTypeCount = 0;
        
        if (options.uppercase) {
            password += uppercaseChars.charAt(Math.floor(Math.random() * uppercaseChars.length));
            charTypeCount++;
        }
        
        if (options.lowercase) {
            password += lowercaseChars.charAt(Math.floor(Math.random() * lowercaseChars.length));
            charTypeCount++;
        }
        
        if (options.numbers) {
            password += numberChars.charAt(Math.floor(Math.random() * numberChars.length));
            charTypeCount++;
        }
        
        if (options.symbols) {
            password += symbolChars.charAt(Math.floor(Math.random() * symbolChars.length));
            charTypeCount++;
        }
        
        // 填充剩余的密码长度
        for (let i = charTypeCount; i < length; i++) {
            const randomIndex = Math.floor(Math.random() * chars.length);
            password += chars.charAt(randomIndex);
        }
        
        // 打乱密码字符顺序
        password = password.split('')
            .sort(() => 0.5 - Math.random())
            .join('');
            
        return password;
    }
}; 